package test;


/**
 * 混乱的键盘
 * 小可每天都要将很多文件输入到电脑里面去，由于键盘长期的使用，导致键盘出现了一些bug,如果你连续敲击了某个键k次后，
 * 再次敲击该键位的话，却不会有任何的输入，这个bug可以通过两种方式解决，一种是在这个时候敲击另一个键位，或者是再敲击k次这个键位，从而使得这个bug 被修复。
 *
 *   现在小可又收到了一份文件，文件里面有着一堆这样的连续的需要被键入的文字，但是由于小可使用的键盘是特制的字符集巨大的键盘，所以她不能使用删除键来进行操作，
 *   所以小可想知道，如果她需要输入接下来这个文件，那么她需要以怎样的方式来敲击键盘？但如果你把小可需要输出的字符丢在她面前，那也过于冗长了，因此小可只想知道对于每个键小可需要敲击多少次。
 *
 *   输入数据共n+1行
 * 第一行输入2个整数 n,k，表示文件的连续段数目和产生 bug 的临界值。
 * 接下来行每行2个正整数ai,bi，表示ai这个字符将会紧接着输入bi次。
 * 对于所有的数据，1≤n,k≤105,ai≤109,bi≤109
 *
 * 输出共m+1行（m为字符的种类数）
 * 第一行 输出一个整数m，表示小可需要敲击的键位数。
 * 接下来m行每行两个正整数ci,di,表示ci这个字符键被敲击了di次。注意此处需要按照ci大小从小往大的顺序输出。
 *
 * 6 4
 * 1 3
 * 1 3
 * 2 1
 * 1 9
 * 2 2
 * 2 10
 *
 * 输出
 * 2
 * 1 27
 * 2 21
 */
import java.util.*;
class Main5{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        Map<Integer,Integer> map = new HashMap<>();
        for(int i=0;i<n;i++){
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            map.put(a,map.getOrDefault(a,0)+b);
//            if(b<k)
//                map.put(a, map.getOrDefault(a,0)+b);
//            else{
//                int m = b / k;
//                int r = b % k;
//                for(int j=0;j<m;j++){
//                    map.put(a,map.getOrDefault(a,0)+k*m);
//                }
//                if(r>0){
//                    map.put(a,map.getOrDefault(a,0)+r+k);
//                }
//            }
        }
        System.out.println(map.size());
        for(Map.Entry<Integer,Integer> entry : map.entrySet()){
            int ans = entry.getValue();
            int r = ans % k;
            if(r==1)
                ans = ans + (ans/k)*k-k;
            else if(k==2)
                ans = ans + (ans/k)*k;
            else if(k==3)
                ans = ans + (ans/ k)*k;
            else
                ans = ans + (ans/ k)*k;
            System.out.println(entry.getKey()+ " " + ans);
        }
    }
}


/**
 * 吞吞大作战
 *吞吞大作战是球球大作战的x.0版本，此时球球并不能通过击败其他球球壮大自己，而是获得得分，每一个球球都有一个能量值a_i，能量大的球球可以击败能量小的球球，当一个球球被击败后，击败者可以获得b_i得分。
 *但是为了和谐，每个球球最多只能击败m个其他球球，然后就会强制进入结算环节。数据保证不会有两个球球具有相同的能量值。
 *请问每个球球最终最多得分多少。
 *
 * 输入第一行包含两个正整数n和m，表示球球的数量，和每个球球最多击败其他球球的数量。(1<=n,m<=1e5)
 *
 * 输入第二行包含n个非负整数，表示每个球球的能量值，每个数都不大于100000。
 *
 * 输入第三行包含n个正整数，表示每个球球的被击败后对手获得的得分，每个整数都不大于100000。
 *
 * 输出包含n个整数，表示每个球球最终最多获得的分数。
 *
 * 5 3
 * 1 3 5 2 4
 * 1 2 3 4 5
 *
 * shuchu
 * 0 5 11 1 7
 */
class Main{
    class Ball{
        int engry;
        int score;

        public Ball(int engry, int score){
            this.engry = engry;
            this.score = score;
        }

        public int getEngry() {
            return engry;
        }

        public int getScore() {
            return score;
        }
    }

    public int[] helper(int n, int m, int[] engry, int[] score){
        PriorityQueue<Ball> q = new PriorityQueue<>(Comparator.comparingInt(Ball::getEngry));
        for(int i=0;i<n;i++){
            q.offer(new Ball(engry[i],score[i]));
        }
        int[] maxScores = new int[n];
        for(int i=0;i<n;i++){
            int maxSorce = 0;
            int cnt = 0;
            int currentEngry = engry[i];
            PriorityQueue<Ball> temp = new PriorityQueue<>(Comparator.comparingInt(Ball::getEngry).reversed());
            temp.addAll(q);
            while (!temp.isEmpty() && cnt<m){
                Ball ball = temp.poll();
                if(ball.engry<currentEngry){
                    maxSorce+=ball.score;
                    cnt++;
                }
            }
            maxScores[i] = maxSorce;
        }
        return maxScores;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[] engry = new int[n];
        for(int i=0;i<n;i++)
            engry[i] = scanner.nextInt();
        int[] source = new int[n];
        for(int i=0;i<n;i++)
            source[i] = scanner.nextInt();

        int[] sss = new Main().helper(n, m, engry,source);
//        for(int i=0;i<n;i++){
//            int sum = 0;
//            for(int j=0;j<n;j++){
//                if(engry[i]>engry[j] && sum<m){
//                    sss[i] += source[j];
//                    sum++;
//                }
//            }
//        }
        for(int i=0;i<n;i++)
            System.out.print(sss[i]+" ");
    }
}
/**
 * 区间计数
 * 给出两个长度均为n的数组A={a1,a2,...,an}，B={b1,b2,...,bn}。
 * 你需要求出其有多少个区间[L,R]满足数组A中下标在[L,R]中的元素之和在[La,Ra]之中，且数组B中下标在[L,R]中的元素之和在[Lb,Rb]中。
 *
 * 输入描述
 * 第一行有一个正整数N(1≤N≤100000)，代表两个数组的长度。
 * 第二行有N个非负整数，范围在0到1000000000之间，代表数组中的元素。
 * 第三行有N个非负整数，范围在0到1000000000之间，代表数组中的元素。
 * 第四行有4个整数La,Ra,Lb,Rb，范围在0到1018之间，代表题目描述中的参数。
 *
 * 4
 * 1 4 2 3
 * 2 4 1 1
 * 3 7 4 6
 *
 * 3
 */
class Main4{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        int[] nums1 = new int[N];
        int[] nums2 = new int[N];
        for(int i=0;i<N;i++)
            nums1[i] = scan.nextInt();
        for(int i=0;i<N;i++)
            nums2[i] = scan.nextInt();
        int La = scan.nextInt();
        int Ra = scan.nextInt();
        int Lb = scan.nextInt();
        int Rb = scan.nextInt();
        int cnt = 0;
        for(int i=0;i<N;i++){
            for(int j=i;j<N;j++){
                int sum1 = 0;
                for(int k=i;k<=j;k++){
                    sum1 += nums1[k];
                }
                if(sum1>=La && sum1 <=Ra){
                    int sum2 = 0;
                    for(int k=i;k<=j;k++){
                        sum2+= nums2[k];
                    }
                    if(sum2>=Lb && sum2<=Rb){
                        cnt++;
                    }
                }
            }
        }
        System.out.println(cnt);
    }
}


/**
 * 编程试题：求数列的和
 */
class Main2{
    public static void main(String args[]){
        int m;
        double sum,n;
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            n=sc.nextInt();
            m=sc.nextInt();
            sum=0;
            for(int i=0;i<m;i++){
                sum=sum+n;
                n=Math.sqrt(n);
            }
            System.out.printf("%.2f",sum);
            System.out.println();
        }
    }
}

/**
 * 水仙花数
 */
class Main3{
    public static void main(String args[]){
        Scanner reader=new Scanner(System.in);
        while(reader.hasNextInt()){
            int m=reader.nextInt();
            int n=reader.nextInt();
            if(100<=m&&m<=n&&n<=999){
                int j=0;
                for(int i=m;i<=n;i++)
                {
                    int geWei,shiWei,baiWei;
                    baiWei=i/100;
                    shiWei=(i-baiWei*100)/10;
                    geWei=i-baiWei*100-shiWei*10;
                    if(i==geWei*geWei*geWei+shiWei*shiWei*shiWei+baiWei*baiWei*baiWei)
                    {j=j+1;
                        if(j>1){
                            System.out.print(" "+i);
                        }
                        else{
                            System.out.print(i);
                        }

                    }
                }
                if(j==0){
                    System.out.print("no");
                }
                System.out.println();
            }
        }
    }
}
